/**
 * 工具函数库
 */

// 获取URL参数
export function getUrlParams() {
	let search = window.location.search;

	// 处理带有逗号的情况，例如 ?type=3,
	if (search.includes(',')) {
		search = search.replace(/,/g, '&');
	}

	const params = new URLSearchParams(search);
	console.log('URL参数:', search);
	console.log('解析的type参数:', params.get('type'));

	return {
		id: params.get('id'),
		type: params.get('type') || '3', // 默认为账密登录(3)
		token: params.get('token'),
		invite_code: params.get('invite_code'),
		platform: params.get('platform')
	};
}

// 显示对应的登录方式
function showLoginType(type) {
	const forms = document.querySelectorAll('.login-form');
	forms.forEach(form => form.classList.remove('active'));

	switch (type) {
		case '1':
			document.getElementById('whatsapp-login').classList.add('active');
			break;
		case '2':
			document.getElementById('facebook-login').classList.add('active');
			break;
		case '3':
			document.getElementById('password-login').classList.add('active');
			break;
		case '4':
			document.getElementById('sms-login').classList.add('active');
			break;
		default:
			document.getElementById('sms-login').classList.add('active');
	}
}


// 发送请求的通用方法
function sendRequest(url, data) {
	const urlParams = getUrlParams();
	const requestData = {
		...data,
		token: urlParams.token,
		id: urlParams.id
	};

	return fetch(url, {
		method: 'POST',
		headers: {
			'Content-Type': 'application/json',
			'Authorization': `Bearer ${urlParams.token}`
		},
		body: JSON.stringify(requestData)
	});
}

function fetchAPI(url, options) {
	return fetch(url, options)
		.then(response => {
			// 首先检查HTTP状态码
			if (!response.ok) {
				// 即使状态码不是2xx，也尝试解析JSON响应
				return response.json().then(errorData => {
					// 将错误数据和状态码包装在一起抛出
					throw {
						status: response.status,
						data: errorData
					};
				}).catch(err => {
					// 如果JSON解析失败，则抛出原始状态
					if (!err.status) {
						throw {
							status: response.status,
							message: response.statusText
						};
					}
					throw err;
				});
			}
			return response.json();
		});
}

/**
 * 处理API错误响应
 * @param {Object} error - 错误对象
 * @param {string} formType - 表单类型 (password, sms, whatsapp, facebook, register, forgot)
 */
function handleAPIError(error, formType) {
	console.error('API Error:', error);

	let errorMessage = '';
	let detailMessages = [];

	// 检查是否有API响应数据
	if (error.data) {
		const apiResponse = error.data;

		// 优先使用API返回的message
		if (apiResponse.message) {
			errorMessage = apiResponse.message;
		}

		// 处理验证错误的详细信息
		if (apiResponse.data && typeof apiResponse.data === 'object') {
			// 提取验证错误的具体字段信息
			for (const [field, message] of Object.entries(apiResponse.data)) {
				detailMessages.push(message);
			}
		}

		// 根据错误代码提供更友好的提示
		if (apiResponse.code) {
			switch (apiResponse.code) {
				case 400:
					if (!errorMessage) {
						errorMessage = '请求参数有误';
					}
					break;
				case 401:
					if (!errorMessage) {
						errorMessage = '认证失败';
					}
					break;
				case 403:
					errorMessage = '权限不足';
					break;
				case 404:
					errorMessage = '请求的资源不存在';
					break;
				case 429:
					errorMessage = '操作过于频繁，请稍后重试';
					break;
				case 500:
					errorMessage = '服务器内部错误，请稍后重试';
					break;
			}
		}
	} else {
		// 处理网络错误或其他HTTP错误
		switch (error.status) {
			case 0:
				errorMessage = '网络连接失败，请检查网络设置';
				break;
			case 408:
				errorMessage = '请求超时，请重试';
				break;
			case 500:
				errorMessage = '服务器内部错误，请稍后重试';
				break;
			case 502:
			case 503:
			case 504:
				errorMessage = '服务暂时不可用，请稍后重试';
				break;
			default:
				errorMessage = error.message || '请求失败，请重试';
		}
	}

	// 组合错误消息
	let fullErrorMessage = errorMessage;
	if (detailMessages.length > 0) {
		fullErrorMessage += '\n' + detailMessages.join('\n');
	}

	// 显示错误信息
	showError(formType, fullErrorMessage);

	// 特殊处理某些错误类型
	if (error.data && error.data.code === 401) {
		// 认证失败，可能需要清除本地存储的认证信息
		// localStorage.removeItem('auth_token');
	}

	return fullErrorMessage;
}

/**
 * 显示错误信息到指定表单
 * @param {string} formType - 表单类型
 * @param {string} message - 错误消息
 */
function showError(formType, message) {
	const errorElement = document.getElementById(`${formType}-error`);
	if (errorElement) {
		errorElement.textContent = message;
		errorElement.style.display = 'block';

		// 3秒后自动隐藏错误信息
		setTimeout(() => {
			hideError(formType);
		}, 5000);
	} else {
		// 如果找不到对应的错误元素，使用alert作为备选
		console.warn(`Error element not found for form type: ${formType}`);
		alert(message);
	}
}

/**
 * 隐藏错误信息
 * @param {string} formType - 表单类型
 */
function hideError(formType) {
	const errorElement = document.getElementById(`${formType}-error`);
	if (errorElement) {
		errorElement.style.display = 'none';
		errorElement.textContent = '';
	}
}

/**
 * 显示成功信息
 * @param {string} formType - 表单类型
 * @param {string} message - 成功消息
 */
function showSuccess(formType, message) {
	const successElement = document.getElementById(`${formType}-success`);
	if (successElement) {
		successElement.textContent = message;
		successElement.style.display = 'block';

		// 3秒后自动隐藏成功信息
		setTimeout(() => {
			hideSuccess(formType);
		}, 3000);
	}
}

/**
 * 隐藏成功信息
 * @param {string} formType - 表单类型
 */
function hideSuccess(formType) {
	const successElement = document.getElementById(`${formType}-success`);
	if (successElement) {
		successElement.style.display = 'none';
		successElement.textContent = '';
	}
}

/**
 * 显示加载状态
 * @param {string} formType - 表单类型
 * @param {boolean} show - 是否显示
 */
function showLoading(formType, show) {
	const loadingElement = document.getElementById(`${formType}-loading`);
	if (loadingElement) {
		loadingElement.style.display = show ? 'block' : 'none';
	}

	// 禁用/启用表单按钮
	const form = document.getElementById(
		`${formType}-${formType === 'password' || formType === 'sms' ? 'login' : formType === 'register' ? 'form' : 'form'}`
	);
	if (form) {
		const submitButton = form.querySelector('button[type="submit"]');
		if (submitButton) {
			submitButton.disabled = show;
			submitButton.textContent = show ? '处理中...' : getOriginalButtonText(formType);
		}
	}
}

/**
 * 获取按钮的原始文本
 * @param {string} formType - 表单类型
 * @returns {string} 按钮文本
 */
function getOriginalButtonText(formType) {
	switch (formType) {
		case 'password':
		case 'sms':
			return '登录';
		case 'register':
			return '注册';
		case 'forgot':
			return '重置密码';
		case 'whatsapp':
			return '通过 WhatsApp 登录';
		case 'facebook':
			return '通过 Facebook 登录';
		default:
			return '提交';
	}
}

/**
 * 清除所有状态信息
 * @param {string} formType - 表单类型
 */
function clearAllStatus(formType) {
	hideError(formType);
	hideSuccess(formType);
	showLoading(formType, false);
}

// 验证手机号码
function validatePhone(phone) {
	// 简单的手机号验证，可根据需要调整
	return /^\d{2}9\d{8}$/.test(phone);
}

// 验证密码
function validatePassword(password) {
	// 密码至少6位
	return password.length >= 6;
}

// 验证两次密码是否一致
function validatePasswordMatch(password, confirmPassword) {
	return password === confirmPassword;
}

// 验证验证码
function validateCode(code) {
	// 验证码为6位数字
	return /^\d{6}$/.test(code);
}

// 模态框相关函数
// ===================================

// 打开模态框
function openModal(modalId) {
	console.log('打开模态框:', modalId);
	const modal = document.getElementById(modalId);
	if (modal) {
		modal.style.display = 'flex';
	} else {
		console.error('找不到模态框元素:', modalId);
	}
}

// 关闭模态框
function closeModal(modalId) {
	console.log('关闭模态框:', modalId);
	const modal = document.getElementById(modalId);
	if (modal) {
		modal.style.display = 'none';
	} else {
		console.error('找不到模态框元素:', modalId);
	}
}

// 发送验证码
function sendVerificationCode(phone, type, btnId) {
	if (!validatePhone(phone)) {
		showError(type, '请输入有效的手机号码');
		return;
	}

	const btn = document.getElementById(btnId);
	btn.disabled = true;

	// 倒计时
	let countdown = 60;
	const originalText = btn.textContent;
	btn.textContent = `${countdown}秒后重新发送`;

	const timer = setInterval(() => {
		countdown--;
		btn.textContent = `${countdown}秒后重新发送`;

		if (countdown <= 0) {
			clearInterval(timer);
			btn.disabled = false;
			btn.textContent = originalText;
		}
	}, 1000);

	// 发送验证码请求
	fetchAPI('/api/send-code', {
			method: 'POST',
			headers: {
				'Content-Type': 'application/json'
			},
			body: JSON.stringify({
				phone: phone,
				type: type // 可以根据不同场景传递不同的type，如 'register', 'forgot'
			})
		})
		.then(data => {
			if (data.code === 200 || data.success) {
				showSuccess(type, '验证码已发送，请查收');
			} else {
				showError(type, data.message || '验证码发送失败');
			}
		})
		.catch(error => {
			handleAPIError(error, type);
		});
}

// 判断浏览器内核的函数
function detectBrowserEngine() {
	const userAgent = navigator.userAgent.toLowerCase();

	// 判断是否为移动端
	const isMobile = /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(userAgent);

	// 判断具体内核
	if (userAgent.indexOf('webkit') > -1) {
		if (userAgent.indexOf('chrome') > -1) {
			return 'blink'; // Chrome、Edge新版本使用Blink内核
		} else if (userAgent.indexOf('safari') > -1) {
			return 'webkit'; // Safari使用WebKit内核
		}
	}

	if (userAgent.indexOf('gecko') > -1 && userAgent.indexOf('firefox') > -1) {
		return 'gecko'; // Firefox使用Gecko内核
	}

	if (userAgent.indexOf('trident') > -1 || userAgent.indexOf('msie') > -1) {
		return 'trident'; // IE使用Trident内核
	}

	// 判断是否在APP内嵌WebView中
	if (window.Android || userAgent.indexOf('android') > -1) {
		return 'android_webview';
	}

	if (window.webkit && window.webkit.messageHandlers) {
		return 'ios_webview';
	}

	return 'unknown';
}

// 根据内核执行不同的登录回调
export const handleLoginSuccess = (token, inviteCode = "test_invite_code") => {
	// 使用url的platform参数，web或native
	// showSuccess('password', '登录成功，正在跳转...');
	let req = getUrlParams()
	if (req.platform == 'web') {
		console.log("web登录方式")
		window.parent.postMessage({
			type: 'login_success',
			token: token,
			inviteCode: req.invite_code
		}, '*');
		return;
	}
	if (req.platform == 'native') {
		console.log("native登录方式")
		window.location.href =
			`login://token=${encodeURIComponent(token)}&inviteCode=${encodeURIComponent(req.invite_code)}`;
		return;
	}
	if (!req.platform) {
		console.log("调试模式")
		window.location.href =
			`login://token=${encodeURIComponent(token)}&inviteCode=${encodeURIComponent(req.invite_code)}`;
		return;
	}
}